/**
 * 员工管理系统 - 认证相关工具函数
 */

// 用于存储登录令牌的键名
const TOKEN_KEY = 'satoken';
// 用于存储用户信息的键名
const USER_INFO_KEY = 'userInfo';

/**
 * 登录函数
 * @param {string} username 用户名
 * @param {string} password 密码
 * @param {string} captcha 验证码
 * @param {string} captchaKey 验证码键值
 * @returns {Promise} 返回Promise对象
 */
function login(username, password, captcha, captchaKey) {
    return new Promise((resolve, reject) => {
        if (!username || !password) {
            reject(new Error('用户名和密码不能为空'));
            return;
        }

        if (!captcha || !captchaKey) {
            reject(new Error('验证码不能为空'));
            return;
        }

        // 构建请求数据
        const data = {
            username: username,
            password: password,
            code: captcha,
            uuid: captchaKey
        };

        // 发送登录请求
        fetch('/lzw/user/login', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json'
            },
            body: JSON.stringify(data)
        })
        .then(response => {
            if (!response.ok) {
                throw new Error(`HTTP error! status: ${response.status}`);
            }
            return response.json();
        })
        .then(result => {
            if (result.code === 200) {
                // 登录成功，保存令牌和用户信息
                const token = result.data;  // 直接使用返回的token字符串
                const userInfo = {
                    userId: null,  // 这些信息后续可以通过用户信息接口获取
                    username: username,
                    permissions: [],
                    roles: []
                };
                
                // 保存到本地存储
                localStorage.setItem(TOKEN_KEY, token);
                localStorage.setItem(USER_INFO_KEY, JSON.stringify(userInfo));
                
                // 获取用户详细信息
                fetch('/lzw/user/info', {
                    headers: {
                        'satoken': token
                    }
                })
                .then(response => response.json())
                .then(userResult => {
                    if (userResult.code === 200) {
                        const fullUserInfo = {
                            userId: userResult.data.id,
                            username: userResult.data.username,
                            permissions: userResult.data.permissions || [],
                            roles: userResult.data.roles || []
                        };
                        localStorage.setItem(USER_INFO_KEY, JSON.stringify(fullUserInfo));
                    }
                })
                .catch(err => console.error('获取用户信息失败', err));
                
                resolve(userInfo);
            } else {
                // 登录失败
                reject(new Error(result.message || '登录失败'));
            }
        })
        .catch(error => {
            reject(error);
        });
    });
}

/**
 * 获取验证码
 * @returns {Promise} 返回Promise对象，包含验证码图片URL和验证码键值
 */
function getCaptcha() {
    return new Promise((resolve, reject) => {
        // 发送获取验证码请求
        fetch('/lzw/captcha', {
            method: 'GET'
        })
        .then(response => {
            if (!response.ok) {
                throw new Error(`HTTP error! status: ${response.status}`);
            }
            return response.json();
        })
        .then(result => {
            if (result.code === 200) {
                resolve({
                    captchaUrl: result.data.img,
                    captchaKey: result.data.uuid
                });
            } else {
                reject(new Error(result.message || '获取验证码失败'));
            }
        })
        .catch(error => {
            reject(error);
        });
    });
}

/**
 * 检查用户是否已登录
 * @returns {boolean} 是否已登录
 */
function isLoggedIn() {
    const token = localStorage.getItem(TOKEN_KEY);
    return !!token;
}

/**
 * 获取当前登录的用户信息
 * @returns {Object|null} 用户信息对象，如果未登录则返回null
 */
function getCurrentUser() {
    if (!isLoggedIn()) {
        return null;
    }
    
    try {
        const userInfoStr = localStorage.getItem(USER_INFO_KEY);
        return userInfoStr ? JSON.parse(userInfoStr) : null;
    } catch (e) {
        console.error('解析用户信息失败:', e);
        return null;
    }
}

/**
 * 获取授权头信息（用于API请求）
 * @returns {Object|null} 包含satoken头的对象，如果未登录则返回null
 */
function getAuthHeader() {
    const token = localStorage.getItem(TOKEN_KEY);
    return token ? { 'satoken': token } : null;
}

/**
 * 退出登录
 * @returns {Promise} 返回Promise对象
 */
function logout() {
    return new Promise((resolve, reject) => {
        // 发送退出登录请求
        fetch('/lzw/logout', {
            method: 'POST',
            headers: {
                ...getAuthHeader(),
                'Content-Type': 'application/json'
            }
        })
        .then(response => {
            // 无论服务器响应如何，都清除本地存储
            localStorage.removeItem(TOKEN_KEY);
            localStorage.removeItem(USER_INFO_KEY);
            resolve();
        })
        .catch(error => {
            // 即使请求失败，也清除本地存储
            localStorage.removeItem(TOKEN_KEY);
            localStorage.removeItem(USER_INFO_KEY);
            resolve();
        });
    });
}

/**
 * 检查用户是否拥有指定权限
 * @param {string} permission 权限标识
 * @returns {boolean} 是否拥有权限
 */
function hasPermission(permission) {
    const user = getCurrentUser();
    if (!user || !user.permissions || user.permissions.length === 0) {
        return false;
    }
    
    return user.permissions.includes(permission);
}

/**
 * 检查用户是否拥有指定角色
 * @param {string} role 角色标识
 * @returns {boolean} 是否拥有角色
 */
function hasRole(role) {
    const user = getCurrentUser();
    if (!user || !user.roles || user.roles.length === 0) {
        return false;
    }
    
    return user.roles.includes(role);
}

/**
 * 刷新令牌
 * @returns {Promise} 返回Promise对象
 */
function refreshToken() {
    return new Promise((resolve, reject) => {
        // 发送刷新令牌请求
        fetch('/lzw/refresh-token', {
            method: 'POST',
            headers: {
                ...getAuthHeader(),
                'Content-Type': 'application/json'
            }
        })
        .then(response => {
            if (!response.ok) {
                throw new Error(`HTTP error! status: ${response.status}`);
            }
            return response.json();
        })
        .then(result => {
            if (result.code === 200) {
                // 保存新令牌
                localStorage.setItem(TOKEN_KEY, result.data.tokenValue);
                resolve();
            } else {
                // 刷新失败，可能需要重新登录
                localStorage.removeItem(TOKEN_KEY);
                localStorage.removeItem(USER_INFO_KEY);
                reject(new Error(result.message || '刷新令牌失败'));
            }
        })
        .catch(error => {
            reject(error);
        });
    });
}

/**
 * 创建一个带有授权头的fetch请求
 * @param {string} url 请求URL
 * @param {Object} options 请求选项
 * @returns {Promise} 返回Promise对象
 */
function authFetch(url, options = {}) {
    const headers = {
        ...options.headers,
        ...getAuthHeader()
    };
    
    return fetch(url, {
        ...options,
        headers
    })
    .then(response => {
        // 如果返回401未授权，可能是令牌过期
        if (response.status === 401) {
            // 尝试刷新令牌
            return refreshToken()
                .then(() => {
                    // 刷新成功，使用新令牌重试请求
                    const newHeaders = {
                        ...options.headers,
                        ...getAuthHeader()
                    };
                    
                    return fetch(url, {
                        ...options,
                        headers: newHeaders
                    });
                })
                .catch(error => {
                    // 刷新失败，可能需要重新登录
                    window.location.href = '/login.html';
                    throw error;
                });
        }
        
        return response;
    });
}

// 应用认证拦截器
window.fetch = authFetch;

// 发送API请求的通用方法
async function apiRequest(url, method = 'GET', data = null) {
  const options = {
    method: method,
    headers: {
      'Content-Type': 'application/json'
    }
  };
  
  // 添加token到请求头
  const token = localStorage.getItem('satoken');
  if (token) {
    options.headers['satoken'] = token;
  }
  
  // 添加请求体
  if (data && (method === 'POST' || method === 'PUT')) {
    options.body = JSON.stringify(data);
  }
  
  try {
    const response = await fetch(url, options);
    
    // 处理未授权的情况
    if (response.status === 401) {
      localStorage.removeItem('satoken');
      localStorage.removeItem('userInfo');
      window.location.href = '/login.html';
      return null;
    }
    
    return await response.json();
  } catch (error) {
    console.error('API请求失败', error);
    return { code: 500, message: '请求失败，请稍后再试' };
  }
} 